import express from 'express';
import cors from 'cors';

const app = express();
const PORT = 3001;

// 中间件
app.use(cors());
app.use(express.json());

// 模拟用户数据（存储在内存中）
const users = [
  {
    id: 1,
    username: 'admin',
    password: '123456',
    name: '系统管理员',
    roles: ['admin', 'landlord', 'tenant'],
    isAdmin: true,
    hasSetRoles: true
  }
];

// 用户ID计数器
let userIdCounter = 2;

// 房东认证信息存储
const landlordVerifications = [];
let verificationIdCounter = 1;

// 角色定义
const roleDefinitions = {
  admin: {
    name: '管理员',
    description: '系统管理员，拥有所有权限',
    permissions: ['manage_users', 'manage_properties', 'manage_rentals', 'view_reports']
  },
  landlord: {
    name: '房东',
    description: '房屋出租方，可以发布和管理房源',
    permissions: ['manage_properties', 'view_rentals', 'manage_tenants']
  },
  tenant: {
    name: '租客',
    description: '房屋承租方，可以搜索和租赁房源',
    permissions: ['search_properties', 'manage_rentals', 'view_profile']
  }
};

// 注册接口
app.post('/api/register', (req, res) => {
  const { username, password, name } = req.body;

  console.log('注册请求:', { username, name });

  // 验证必填字段
  if (!username || !password || !name) {
    return res.status(400).json({
      success: false,
      message: '用户名、密码和姓名不能为空'
    });
  }

  // 验证用户名长度
  if (username.length < 3) {
    return res.status(400).json({
      success: false,
      message: '用户名至少需要3个字符'
    });
  }

  // 验证密码长度
  if (password.length < 6) {
    return res.status(400).json({
      success: false,
      message: '密码至少需要6个字符'
    });
  }

  // 检查用户名是否已存在
  const existingUser = users.find(u => u.username === username);
  if (existingUser) {
    return res.status(409).json({
      success: false,
      message: '用户名已存在'
    });
  }

  // 创建新用户
  const newUser = {
    id: userIdCounter++,
    username: username.trim(),
    password: password,
    name: name.trim(),
    roles: [], // 新用户没有预设角色
    isAdmin: false,
    createdAt: new Date().toISOString()
  };

  users.push(newUser);

  // 返回用户信息（不包含密码）
  const { password: _, ...userInfo } = newUser;

  res.json({
    success: true,
    message: '注册成功',
    data: {
      user: userInfo,
      token: `user_${newUser.id}_permanent` // 永久有效的简单 token
    }
  });
});

// 登录接口
app.post('/api/login', (req, res) => {
  const { username, password } = req.body;

  console.log('登录请求:', { username, password });

  if (!username || !password) {
    return res.status(400).json({
      success: false,
      message: '用户名和密码不能为空'
    });
  }

  const user = users.find(u => u.username === username && u.password === password);

  if (!user) {
    return res.status(401).json({
      success: false,
      message: '用户名或密码错误'
    });
  }

  // 返回用户信息（不包含密码）
  const { password: _, ...userInfo } = user;

  res.json({
    success: true,
    message: '登录成功',
    data: {
      user: userInfo,
      token: `user_${user.id}_permanent` // 永久有效的简单 token
    }
  });
});

// 获取角色定义
app.get('/api/roles', (req, res) => {
  res.json({
    success: true,
    data: roleDefinitions
  });
});

// 用户选择角色
app.post('/api/user/:id/roles', (req, res) => {
  const userId = parseInt(req.params.id);
  const { roles } = req.body;

  console.log('用户选择角色:', { userId, roles });

  if (!roles || !Array.isArray(roles) || roles.length !== 1) {
    return res.status(400).json({
      success: false,
      message: '请选择一个角色'
    });
  }

  // 验证角色是否有效
  const validRoles = Object.keys(roleDefinitions);
  const invalidRoles = roles.filter(role => !validRoles.includes(role));

  if (invalidRoles.length > 0) {
    return res.status(400).json({
      success: false,
      message: `无效的角色: ${invalidRoles.join(', ')}`
    });
  }

  // 查找用户
  const user = users.find(u => u.id === userId);
  if (!user) {
    return res.status(404).json({
      success: false,
      message: '用户不存在'
    });
  }

  // 检查用户是否已经设置过角色（新用户只能设置一次）
  if (user.roles && user.roles.length > 0 && !user.isAdmin) {
    return res.status(403).json({
      success: false,
      message: '角色已设置，不能重复设置'
    });
  }

  // 更新用户角色
  user.roles = roles;
  user.updatedAt = new Date().toISOString();
  user.hasSetRoles = true; // 标记已设置角色

  console.log('用户角色设置成功:', { userId, roles, userName: user.name });

  // 返回更新后的用户信息
  const { password: _, ...userInfo } = user;

  res.json({
    success: true,
    message: '角色设置成功',
    data: userInfo
  });
});

// 获取用户信息
app.get('/api/user/:id', (req, res) => {
  const userId = parseInt(req.params.id);
  const user = users.find(u => u.id === userId);
  
  if (!user) {
    return res.status(404).json({
      success: false,
      message: '用户不存在'
    });
  }
  
  const { password: _, ...userInfo } = user;
  res.json({
    success: true,
    data: userInfo
  });
});

// 房东认证提交
app.post('/api/landlord/verification', (req, res) => {
  const {
    userId,
    name,
    phone,
    idCard,
    address,
    businessLicense,
    idCardPhoto,
    verificationCode
  } = req.body;

  console.log('房东认证请求:', { userId, name, phone });

  // 验证必填字段
  if (!userId || !name || !phone || !idCard || !address) {
    return res.status(400).json({
      success: false,
      message: '请填写所有必填信息'
    });
  }

  // 验证手机号格式
  const phoneRegex = /^1[3-9]\d{9}$/;
  if (!phoneRegex.test(phone)) {
    return res.status(400).json({
      success: false,
      message: '请输入正确的手机号码'
    });
  }

  // 验证身份证号格式（简单验证）
  const idCardRegex = /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/;
  if (!idCardRegex.test(idCard)) {
    return res.status(400).json({
      success: false,
      message: '请输入正确的身份证号码'
    });
  }

  // 验证验证码（模拟验证）
  if (verificationCode !== '123456') {
    return res.status(400).json({
      success: false,
      message: '验证码错误'
    });
  }

  // 查找用户
  const user = users.find(u => u.id === parseInt(userId));
  if (!user) {
    return res.status(404).json({
      success: false,
      message: '用户不存在'
    });
  }

  // 检查是否已经提交过认证
  const existingVerification = landlordVerifications.find(v => v.userId === parseInt(userId));
  if (existingVerification) {
    return res.status(409).json({
      success: false,
      message: '您已提交过认证申请，请等待审核结果'
    });
  }

  // 创建认证记录
  const verification = {
    id: verificationIdCounter++,
    userId: parseInt(userId),
    name: name.trim(),
    phone: phone.trim(),
    idCard: idCard.trim(),
    address: address.trim(),
    businessLicense: businessLicense || '已上传', // 模拟文件上传
    idCardPhoto: idCardPhoto || '已上传', // 模拟文件上传
    status: 'pending', // pending, approved, rejected
    submittedAt: new Date().toISOString(),
    reviewedAt: null,
    reviewComment: null
  };

  landlordVerifications.push(verification);

  // 更新用户信息，添加认证状态
  user.landlordVerification = {
    status: 'pending',
    submittedAt: verification.submittedAt
  };

  console.log('房东认证提交成功:', { userId, verificationId: verification.id });

  res.json({
    success: true,
    message: '认证申请提交成功，我们将在3-5个工作日内完成审核',
    data: {
      verificationId: verification.id,
      status: verification.status,
      submittedAt: verification.submittedAt
    }
  });
});

// 获取房东认证状态
app.get('/api/landlord/verification/:userId', (req, res) => {
  const userId = parseInt(req.params.userId);

  const verification = landlordVerifications.find(v => v.userId === userId);

  if (!verification) {
    return res.status(404).json({
      success: false,
      message: '未找到认证记录'
    });
  }

  // 返回认证信息（不包含敏感信息）
  const { idCard, ...safeVerification } = verification;

  res.json({
    success: true,
    data: {
      ...safeVerification,
      idCard: idCard.replace(/(\d{6})\d{8}(\d{4})/, '$1********$2') // 脱敏处理
    }
  });
});

// 健康检查
app.get('/api/health', (req, res) => {
  res.json({
    success: true,
    message: '服务器运行正常',
    timestamp: new Date().toISOString()
  });
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`🚀 服务器启动成功！`);
  console.log(`📍 地址: http://localhost:${PORT}`);
  console.log(`� 管理员账户: admin / 123456`);
  console.log(`📝 用户可以自由注册并选择角色`);
  console.log(`📊 当前用户数量: ${users.length}`);
});
